package lei;

/**
 * @className: day20250420
 * @author: xl
 * @date: 2025/4/20 19:49
 * @Version: 1.0
 * @description:
 */

public class 重点知识 {
    public static void main(String[] args) {
        /**
         * java变量的存储位置
         *
         *  1、栈：局部变量
         *  2、堆：常量、实例变量、List
         *  3、方法区：静态变量、方法、类加载器
         */

        /**
         * 什么是事物
         *  1、事物是纸对一系列操作组成的一个工作单元，要么全部失败、要么全部成功。
         *
         *  事物的属性
         *      1、原子行：事物中的操作是原子行，要么全部成功，要么全部失败。
         *      2、一致性：事物中的操作是按照顺序进行的，不会因为前面的操作失败而影响后面的操作。
         *      3、隔离性：事物中的操作是隔离的，不会影响其他事物。
         *      4、持久性：事物中的操作是持久的，即 changes made by a transaction are permanent and consistent.
         */

        /**
         *  什么是锁
         *
         *      锁是资源上的互斥访问，即一个资源只能被一个线程访问，其他线程必须等待。
         *
         *      1、乐观锁
         *          是对共享资源的一个操作、每次访问前，都认为线程是安全的，不会出现问题，所以无需等待，只有
         *          在修改共享资源的时候才会加上一把锁。主要有两种方式   1、通过版本好；2：通过csa机制。
         *
         *     2、悲观锁
         *          是对共享资源的一个访问，每次访问都认为是不安全的，所以每次访问都的加上一把锁，只有等上一个线程访问完
         *          下一个线程才能进程访问
         */

        /**
         * 线程池
         *  1、单线程池
         *  2、缓存线程池
         *  3、固定线程池
         *  4、手动线程池
         *      // 核心线程数
         *         int corePoolSize = 2;
         *         // 最大线程数
         *         int maximumPoolSize = 4;
         *         // 空闲线程存活时间
         *         long keepAliveTime = 10;
         *         // 时间单位
         *         TimeUnit unit = TimeUnit.SECONDS;
         *         // 任务队列
         *         BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2);
         *         // 线程工厂
         *         ThreadFactory threadFactory = Executors.defaultThreadFactory();
         *         // 拒绝策略
         *         RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
         *
         *         // 创建线程池
         *         ThreadPoolExecutor executor = new ThreadPoolExecutor(
         *             corePoolSize,
         *             maximumPoolSize,
         *             keepAliveTime,
         *             unit,
         *             workQueue,
         *             threadFactory,
         *             handler
         *         );
         *         // 提交任务
         *         for (int i = 0; i < 10; i++) {
         *             final int taskId = i;
         *             executor.submit(() -> {
         *                 System.out.println("Task ID: " + taskId + " is running by " + Thread.currentThread().getName());
         *                 try {
         *                     Thread.sleep(2000); // 模拟任务耗时
         *                 } catch (InterruptedException e) {
         *                     e.printStackTrace();
         *                 }
         *             });
         *         }
         *
         *         // 关闭线程池
         *         executor.shutdown();
         */


        /**
         * 压力测试
         * 压力测试是指对系统不断施加压力，直到系统性能到达极限甚至崩溃为止，目的是确定系统的稳定性和可靠性。具体来说：
         *
         * 目标：发现系统在极端条件下的瓶颈、稳定性问题以及恢复能力。
         * 方法：通过不断增加工作负载（如增加并发用户数、请求频率等），直到系统性能下降或系统无法处理更多请求。
         * 应用场景：通常用于测试系统在高负载情况下的行为，了解系统在资源耗尽时的表现，比如CPU、内存、磁盘I/O或者网络带宽的限制
         *    关注指标：错误率，资源利用率，CPU的使用率
         *
         * 负载测试
         * 负载测试则是评估系统在预期负载下的性能表现。其主要目的是验证系统是否能够满足日常使用需求，并确保系统能够在预定义的服务水平下正常运行。具体内容包括：
         *
         * 目标：验证系统在特定负载条件下是否能够稳定运行，保证响应时间、吞吐量等性能指标符合要求。
         * 方法：模拟实际业务场景中的用户操作，按照预期的负载量来运行系统，观察系统的响应速度、吞吐量等关键性能指标。
         * 应用场景：主要用于确定系统在正常及峰值负载下的性能表现，帮助识别性能瓶颈，确保系统能够支持预定的用户数量和服务级别协议（SLA）。
         *      关注指标：吞吐量、并发量、响应时间
         *
         *
         * 如何提高接口的性能
         *      1、从硬件上
         *          1、负载均衡
         *          2、硬件设施
         *      2、从代码上
         *          1、算法优化
         *          2、缓存上
         *          3、增加线程池
         *          4、并发处理
         *          5、使用异步处理
         *          6、分库分表上
         *      3、从dao层上
         *          1、使用索引进行优化
         *          2、慢sql治理
         *          3、提高数据库的读写速度
         *              1、在使用锁的时候，读写时尽量使用乐观锁
         *
         */

        /**
         * jmeter的配置元器件
         *  1、配置元器件
         *  2、前置处理器
         *  3、定时器
         *  4、取样器
         *  5、后置处理器
         *  6、断言
         *  7、监听器
         *
         *  如何使用jmeter进行参数化
         *      1、变量的提取
         *          使用正则表达式
         *          使用jsonpath提取起
         *          使用函数助手
         *      2、jmeter变量的使用
         *          定义的变量：${aa}
         *          函数变量：${__time()}
         *
         * jemter如何进行参数化
         *  1、准备测试数据
         *  2、创建测试计划
         *  3、创建线程组
         *  4、添加CSV 数据集
         *  5、添加循环前期
         *  6、添加https请求
         *  7、添加断言
         *  8、添加监听器
         */

        /**
         * 断言的方式有哪些
         *  1、响应头断言
         *  2、响应体的断言
         *  3、响应时间断言
         *  4、响应状态断言
         */

        /**
         * java8的特性有哪些
         *  1、stream流的使用
         *      1、创建流：list.stream()
         *      2、中间流操作：file，map，filter，flatMap，sorted，distinct，limit，skip，peek，parallel，sequential，unordered
         *      3、终端流操作：forEach，collect，count，max，min，anyMatch，allMatch，noneMatch，findFirst，findAny，toArray，reduce，forEachOrdered，
         *
         *  2、lambda表达式的使用
         *      （）->{}
         *
         *  3、方法引用的使用
         *      1、引用静态方法：类名::方法名
         *
         *  4、函数式接口的使用
         *      1、函数式接口：只有一个抽象方法的接口
         *
         *      常见的函数接口
         *          1、消费型接口：Consumer<T>  给一个参数，没有返回值
         *
         *          2、供给型接口：Supplier<T>  不接受参数，有返回值
         *
         *          3、函数型接口：Function<T,R> 给一个参数，有返回值
         *
         *          4、断言型接口：Predicate<T>  给一个参数，返回一个布尔值
         *
         * 时间的处理
         *      LocalDateTime.now()
         *
         *
         */


        /**
         * 你有哪些优缺点
         *      1、对于自动化的编写，过于最求代码的完美
         *      2、对于公开的能力的演讲有待提升
         */


        /**
         * 测试过程中，遇到过哪些困难
         *  1、需求完善
         *
         *  2、测试环境稳定
         *
         *  3、测试数据不完成
         *
         *  4、缺陷定位困难
         *
         *  5、测试时间紧张
         */


        /**
         * mysql
         *
         * 删除： delete from 表名 where 条件
         *
         * 修改 ：update 表名 set 字段名=值 where 条件
         *
         * 插入：insert into 表名(字段名) values(值)
         *
         * 查询  select * from 表名 where 条件
         *      左查询：表名 left join 表名 on 表名.字段名=表名.字段名
         *
         *      右查询：表名 right join 表名 on 表名.字段名=表名.字段名
         *
         *      全查询：表名 full join 表名 on 表名.字段名=表名.字段名
         *
         *      内查询：表名 inner join 表名 on 表名.字段名=表名.字段名
         */


        /**
         * 出现复现不了的bug 怎么办
         *  1、首先尝试在不同的环境尽量复现bug，如果复现不了，详细记录这个bug的其功能情况
         *     并把操作步骤详细记录下来，然后与开发保持密切的沟通，共同解决这个问题
         */

        /**
         * 如果和开发意见发生不一直，你会怎么办
         *  1、双方都先冷静下来，思考一下对方提出的问题，在进行密切的沟通，如果还是不想，寻求第三方的帮助
         */

        /**
         * 需求发生变量怎么办
         *  1、拉去对用的人员重新评估下需求，以及对应的人力，在同步给对用的人员，在重新更新测试计划
         */


        /**
         * 你发现过哪些重要的bug
         *  1、数组越界
         *  2、对于批量操作，没有做事物处理，导致数据不一致
         *  3、对于金额的处理，没有做精度的判断，导致金额出现误差
         *  4、接口响应超时
         *  5、业务逻辑与需求不符
         *
         *
         *  在一个电子商务平台的开发项目中，我负责前端和后端的集成测试。
         *  在一次针对购物车功能的压力测试中，我发现了一个严重的并发问题：
         *  当多个用户同时尝试购买同一件库存有限的商品时，系统偶尔会允许销售超过实际库存数量的商品。
         *  这个问题直接影响到了公司的财务记录准确性和客户信任度。
         *
         * 通过使用JMeter模拟高并发用户场景，并结合日志分析，
         * 我定位到了问题根源在于库存更新机制未能正确处理并发请求。
         * 我将此问题报告给开发团队，并与他们一起工作，提出了采用乐观锁机制作为解决方案。
         * 最终，经过多次迭代测试，我们成功解决了这个问题，确保了系统在高并发情况下的稳定性
         */


        /**
         * 软件错误有哪些
         *      1、接口设计错误
         *      2、参数输入输出错误
         *      3、功能错误、
         *      4、安全错误
         *      5、网络错误
         *      6、上游系统错误
         * 1、
         */

        /**
         * 接口请求不同的原因有哪些
         *  1、url错误
         *  2、端口错误
         *  3、ip错误
         *  4、请求方式错误
         *  5、参数错误
         *  6、服务器内部错误
         *  7、网络错误
         *  8、权限错误
         */


        /**
         * 接口响应的状态码
         *  400：参数错误
         *  401：接口未鉴权
         *  403：接口未授
         *  404：请求的资源不存在
         *
         *  500：服务其内部错误
         *  502：网关错误
         *  503：服务不可用
         *  504：服务器超时
         */

        /**
         * 接口请求的过程
         *  1、发送请求
         *  2、DNS解析
         *  3、服务器接受数据
         *  4、服务器处理数据
         *  5、服务器返回数据
         *  6、客户端接受数据
         *  7、客户端处理数据
         */

        /**
         * tcp的三次握手
         *  1、客户端发送一个SYN包，表示发送一个连接请求
         *  2、服务器收到请求后，发送一个SYN+ACK包，表示发送一个连接确认
         *  3、客户端收到服务器的SYN+ACK包后，发送一个ACK包，表示发送一个连接确认
         */

        /**
         * get请求和post请求的区别
         *  1、get请求的参数在url中传递，post请求的参数在请求体中传递
         *  2、get请求的参数长度有限制，post请求的参数长度无限制
         *  3、get请求的参数可以被缓存，post请求的参数不可以被缓存
         *  4、幂等性：get请求幂等性，post请求不幂等性
         */

        /**
         * http和https
         *  1、http是明文传输，https是加密传输
         *  2、http是80端口，https是443端口
         *  3、证书是用来认证服务器的
         */

        /**
         * mave的生命周期
         *  clear
         *  compile
         *  test
         *  package
         *  install
         *  deploy
         */

        /**
         * git的项目命令
         *  1、创建分支本：git branch 分支名
         *  2、切换分支：git checkout 分支名
         *  3、删除分支：git branch -d 分支名
         *
         *  4、克隆代码：git clone url
         *  5、提交代码：git add . && git commit -m "提交信息" && git push origin 分支名
         *  5、查看提交记录：git log
         *  6、合并代码：git merge 分支名
         *  7、
         */

        /**
         * postman的使用
         *  1、设置全部变量  pm.setGlobalVariable("变量名", "变量值")
         *  2、设置局部变量  pm.setEnvironmentVariable("变量名", "变量值")
         *
         *  post的断言
         *      响应状态吗断言 ：pm.test("响应状态吗断言", function () {pm.response.to.have.status()})
         *      响应时间断言：pm.test("响应时间断言", function () {pm.expect(pm.response.responseTime).to.be.below(1000)})
         *
         *      响应体的断言：
         *      pm.test("响应体的断言", function () {pm.response.to.have.body("响应体断言")})
         *      pm.test("响应体的断言", function () {pm.response().test().include()})
         *      pm.test("响应体的断言", function () {pm.response().test().equles()})
         *
         *      const jsondate=pm.reponse.Json()
         *      pm.test("响应体的断言", function () {pm.expecr(json.code).to.eql(1)})
         *
         *
         */

        /**
         * linux命令的使用
         * 1、查看进程 ps -ef | grep 进程名
         *
         * 2、查看服务器状态：top
         *
         * 3、查看端口：netstat -antp | grep 端口号     lsof -i:端口号
         *
         * 4、查看磁盘空间：df -h
         *
         * 5、查看日志
         *      tail -f 100 app.log
         *
         *      tail -n 100 app.log | grep "aa"
         */


        /**
         * 如何做接口自动化
         *      1、根据需求文档，分析接口的可行性，并筛选出对于的接口
         *      2、编写测试用例，并准备测试数据
         *      3、使用Java+testng+mybatis-plus+httplecl/restassured，接口自动化框架
         *
         *      4、使用@test注解编写测试用用例，并接口RestAssured编写http请求，结合dataProvider实现数据驱动
         *      5、封装一些数据库的操作，以及一些断言的操作，以及https请求的一些操作
         *      6、使用jenkins和gitlab实现自动化
         */

        /**
         * 如何解决登陆太的问题
         *
         * 1、首先我们的知道接口鉴权的方式大致有三种
         *      1、cookies
         *      2、session
         *      4、token
         *
         *
         * 我们以token的方式为例
         *   第一种：
         *      1、首先我们使用jmeter 来发送请求，获取token
         *      2、将token保存到全局变量中，使用${token}的方式来获取token
         *      3、在发送请求的时候，使用${token}的方式来获取token
         *   第二种，使用Java自动机的方式
         *      1、我们首先在请求需求鉴权的接口的使用， 首先等登陆后，获取到token，然后保持成一个变量
         *      2、在请求接口的使用，我们将token放在请求头中，发起请你去
         */


        /**
         * mq消息的测试
         *      1、正常消息的测试
         *          1、生产者是否能正常发送消息
         *          2、消费者是否能正常消费消息
         *          3、消息的延迟
         *          4、消息顺序
         *     2、消息的可可靠性测试
         *          1、发送者的可靠性
         *              1、ack确认机制
         *          2、队列的可靠性测试
         *              1、通过存储消息到磁盘
         *              2、消息重试失败后，竟然私信队列，
         *          3、消费者的可靠性
         *              1、ack确认机制
         *              2、重试机制
         *
         *
         * 消息的异常测试
         *      1、消息的幂等
         *      2、队列当即
         *      3、消费者错误
         *      4、消息发送过大
         *      5、订阅错误
         *
         * 性能测试
         *      1、高吞下量生产消息
         *      2、高并发量处理消息
         *      3、消息的堆积能力  ：处理，限流、增加临时队列
         *
         *
         *  消息丢失问题
         *      生产者
         *          网络抖动
         *          配置错误
         *          消息过大
         *
         *      队列
         *          队列容量太小
         *          当即了
         *          配置错误
         *
         *      消费者
         *          消息超时
         *          消息过载

         *  消息堆积问题
         *      1、网络故障
         *      2、消息过大
         *      3、队列容量太小
         *      4、配置不当
         *      5、突发流量
         *      6、消息的处理时间大于消息生产的时间
         *
         *
         *  死性队列问题
         *      1、消费者异常
         *      2、消息被拒绝
         *      3、消息过大
         *      4、超过重试次数
         *      5、路由失败
         *
         */

        /**
         * 消息幂等
         *  1、消息ID
         *  2、业务ID
         *  3、数据库主建
         */

        /**
         * 消息顺序
         *      如何确保消息的顺序
         *          1、确保同一个业务类型新的消息发送带同一个队列
         */


        /**
         * 登陆用例
         */


        /**
         * 支付用例
         */


        /**
         * 发红包用例
         */

        /**
         * 取款用例
         */


        /**
         * ✅ 1. == 运算符
         * 作用： 比较两个变量的 值是否相等。
         * 对于基本类型（如 int、char、boolean 等）：
         * 比较的是 实际的值。
         * 对于引用类型（如 String、Object 等对象）：
         * 比较的是 对象的内存地址（即是否指向同一个对象）。
         *
         *
         *
         * ✅ 2. equals() 方法
         * 作用： 是 Object 类的方法，用于比较两个对象的 内容是否相等。
         * 默认行为： 与 == 相同，比较的是对象的内存地址。
         * 但很多类（如 String、Integer、List 等）都重写了 equals() 方法，使其比较对象的内容。
         * 示例：
         *
         *
         * ✅ 推荐使用场景
         * 基本类型比较： 使用 ==
         * 对象内容比较： 使用 equals()（前提是该类已重写 equals()）
         * 判断是否为同一对象： 使用 ==
         */
    }
}

